import UploadFile from '@/components/UploadExcel/index';
import { downloadTemplateByName } from '@/services/baseData/fileData';
import { userList } from '@/services/login/login';
import { licenseOrderList } from '@/services/sales/licenseOrder';
import {
  addAfterSalesNeedInfoEx,
  addTempAfterSalesNeedInfoEx,
  afterSalesDetailExport,
  getAfterSalesNeedInfoDetailById,
  getS210motorList,
  getV90motorList,
  updateAfterSalesNeedInfoEx,
  updateTempAfterSalesNeedInfoEx,
} from '@/services/sales/salesNeedInfo';
import { CloseCircleOutlined, PlusOutlined } from '@ant-design/icons';
import type { EditableFormInstance, ProColumns, ProFormInstance } from '@ant-design/pro-components';
import { ProFormDigit } from '@ant-design/pro-components';
import ProForm, { ProFormSelect, ProFormText } from '@ant-design/pro-form';
import { FooterToolbar, PageHeaderWrapper } from '@ant-design/pro-layout';
import { Button, Card, Col, Input, InputNumber, message, Popover, Row, Select } from 'antd';

import { Form } from 'antd';
import React, { useEffect, useRef, useState } from 'react';
import { history, useAccess, useLocation, useModel } from 'umi';
import styles from './style.less';

import DebounceSelect from '@/components/DebounceSelect';

import { EditableProTable } from '@ant-design/pro-table';

// 需要在切换不同状态的时候置空
const rowNullData = {
  motorId: null, //电机ID
  ratedCurrent: null, //额定电流(A)
  ratedTorque: null, //额定扭矩(Nm)
  ratedPower: null, //额定功率(KW)
  ecoderType: null, //编码器
  brake: null, //抱闸
  ratedSpeed: null, //额定速度(rpm)
  ratedVoltage: null, //额定电压(V)
  motorInertia: null, //电机惯量(10^-4kg·cm2)
};

interface TableFormDateType {
  id: string;
  workId?: string;
  name?: string;
  department?: string;
  isNew?: boolean;
  editable?: boolean;
}
const fieldLabels = {
  name: '仓库名',
  url: '仓库域名',
  owner: '仓库管理员',
  approver: '审批人',
  dateRange: '生效日期',
  type: '仓库类型',
  name2: '任务名',
  url2: '任务描述',
  owner2: '执行人',
  approver2: '责任人',
  dateRange2: '生效日期',
  type2: '任务类型',
};
const tableData = [
  {
    key: '1',
    workId: '00001',
    name: 'John Brown',
    department: 'New York No. 1 Lake Park',
  },
  {
    key: '2',
    workId: '00002',
    name: 'Jim Green',
    department: 'London No. 1 Lake Park',
  },
  {
    key: '3',
    workId: '00003',
    name: 'Joe Black',
    department: 'Sidney No. 1 Lake Park',
  },
];

interface UserValue {
  label: string;
  value: string;
}
async function fetchV90motorList(username: string): Promise<UserValue[]> {
  console.log('fetching user', username);
  return getV90motorList({ blurry: username }).then((res) => {
    res.data.push({ motorOrderNum: '第三方', id: '第三方' });
    console.log(res, '---res---');
    return res.data.map((item) => {
      return {
        key: item.id,
        label: item.motorOrderNum,
        value: item.motorOrderNum,
        rowData: item,
      };
    });
  });
}

async function fetchS210motorList(username: string): Promise<UserValue[]> {
  console.log('fetching user', username);
  return getS210motorList({ blurry: username }).then((res) => {
    res.data.push({ motorOrderNum: '第三方', id: '第三方' });
    return res.data.map((item) => {
      return {
        key: item.id,
        label: item.motorOrderNum,
        value: item.motorOrderNum,
        rowData: item,
      };
    });
  });
}

const SalesNeedInfoDetail: React.FC<{}> = () => {
  // const params = useParams();
  const location = useLocation();
  // console.log(params, '---ceshi---');
  console.log(location.query.id, '---ceshi1---');

  const [formTitle, setFormTitle] = useState('新建售后需求'); //
  const [errorStatus, SetErrorStatus] = useState(false); //显示上传预览

  const actionRef = useRef<ActionType>();
  const [showUploadFile, SetShowUploadFile] = useState(false); //显示上传预览
  const editorFormRef = useRef<EditableFormInstance<DataSourceType>>();
  const [form] = Form.useForm();
  // 表格数据
  const [dataSource, setDataSource] = useState<DataSourceType[]>([]);

  const [v90Select, setV90Select] = useState(false); //选择了v90
  const [thirdSelect, setThirdSelect] = useState(false); //选择了第三方

  const [formDisabled, setFormDisabled] = useState(false); //设置表单禁用

  const access = useAccess(); // access 实例的成员: canReadFoo, canUpdateFoo, canDeleteFoo

  // 个人用户数据
  let user = {};
  let deviceInfo = {};

  const { initialState } = useModel('@@initialState');
  const { currentUser } = initialState || {};
  console.log(currentUser, '---currentUser---');

  useEffect(() => {
    // Using an IIFE
    // debugger;
    (async () => {
      // 相当于新建
      if (location.query.id !== undefined && location.query.id !== null) {
        const result = await getAfterSalesNeedInfoDetailById({ id: location.query.id });
        setFormDisabled(true);
        setDataSource(result?.data?.shaftInfoExList);
        user = result?.data?.userEx;
        deviceInfo = result?.data?.deviceInfoEx;
        formRef?.current?.setFieldsValue({
          userId: { label: user?.name, value: user?.id },
          licensOrderId: {
            label: result?.data?.licenseOrderNum,
            value: result?.data?.licenseOrderNum,
          },
          licenseCount: result?.data?.licenseCount,
          driveName: deviceInfo?.deviceName,
          vm: deviceInfo?.vm,
          isProduction: deviceInfo?.production,
          plcType: deviceInfo?.plcType,
        });
      }
    })();
  }, []);
  console.log(location.query.id, '--location.query.id---');
  console.log(location.query.status, '--location.query.status---');
  const formAdd = location.query.id === null || location.query.id === undefined ? true : false;
  // setDataSource([{ id: '00111', identification: '12', motorOrderNum: 'weew' }]);

  /**
   * 穿梭框的数据设置
   */

  const formRef = useRef<
    ProFormInstance<{
      name: string;
      company?: string;
      useMode?: string;
    }>
  >();
  const columns: ProColumns[] = [
    {
      title: '序号',
      align: 'center',
      sorter: true,
      dataIndex: 'index',
      valueType: 'index',
      width: 80,
    },

    {
      title: '轴名称', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'shaftName', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 120,
    },

    {
      title: '硬件标识符', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'hardwareIdentifier', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 120,
      valueType: 'digit',
    },

    {
      title: '驱动类型', //
      search: false,
      align: 'center',
      sorter: true,
      key: 'driveType',
      dataIndex: 'driveType',
      valueType: 'select',
      valueEnum: {
        1: { text: 'V90', status: 'Default' },
        2: {
          text: 'S210',
          status: 'success',
        },
        // 0: {
        //   text: '第三方',
        //   status: 'warning',
        // },
      },

      fieldProps: (_, config, data) => {
        // console.log(_, config, data);
        return {
          onChange: (value, rowData) => {
            console.log(value, '--value---');
            const rowkey = config?.rowKey[0];
            const rowTepm = _.getFieldsValue();
            const rowResult = rowTepm[rowkey];
            if (value === 1) {
              setV90Select(true);
            } else {
              setV90Select(false);
            }
            // console.log(rowkey, rowTepm, rowResult, '---ceshi--');
            editorFormRef.current?.setRowData?.(config?.rowKey[0], {
              ...rowResult,
              motorOrderNum: null,
              ...rowNullData,
            });
          },
        };
      },

      formItemProps: {
        rules: [
          {
            required: true,
            message: '此项是必填项',
          },
        ],
      },
    },

    {
      title: '电机订货号', //
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'motorOrderNum',
      width: 200,
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        if (config.record.driveType === '1') {
          return (
            <DebounceSelect
              // value={value}
              placeholder="v90"
              fetchOptions={fetchV90motorList}
              onChange={(newValue, rowDate) => {
                // console.log(rowDate.rowData, newValue, '-----newValue---');
                if (newValue === '第三方') {
                  editorFormRef.current?.setRowData?.(config?.recordKey, {
                    ...rowDate.rowData,
                    ...rowNullData,
                  });
                  setThirdSelect(true);
                } else {
                  editorFormRef.current?.setRowData?.(config?.recordKey, {
                    ...rowDate.rowData,
                  });
                  setThirdSelect(false);
                }
              }}
              style={{ width: '100%' }}
            />
          );
        } else if (config.record.driveType === '2') {
          return (
            //这个是v210
            <DebounceSelect
              // value={value}
              placeholder="s210"
              fetchOptions={fetchS210motorList}
              onChange={(newValue, rowDate) => {
                // console.log(rowDate, '-----newValue---');
                if (newValue === '第三方') {
                  editorFormRef.current?.setRowData?.(config?.recordKey, {
                    ...rowDate.rowData,
                    ...rowNullData,
                  });
                  setThirdSelect(true);
                } else {
                  editorFormRef.current?.setRowData?.(config?.recordKey, {
                    ...rowDate.rowData,
                  });
                  setThirdSelect(false);
                }
              }}
              style={{ width: '100%' }}
            />
          );
        } else {
          return <Input />;
        }
      },
    },

    {
      title: '电机ID', //表头显示的名称
      search: false,
      //align: 'center',sorter: true,
      dataIndex: 'motorId', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      // valueType: 'digit',
      // editable: (_, text, record) => {
      //   console.log(_, text, record, '--editable-');
      //   return true;
      // },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90

        return (
          <InputNumber disabled={config.record.motorOrderNum !== '第三方'} min={0} max={100} />
        );
      },
    },
    {
      title: '额定电流(A)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'ratedCurrent',

      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90

        return (
          <InputNumber disabled={config.record.motorOrderNum !== '第三方'} min={0} max={200} />
        );
      },
    },
    {
      title: '额定扭矩(Nm)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'ratedTorque', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'digit',
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <InputNumber disabled={config.record.motorOrderNum !== '第三方'} min={0} max={200} />
        );
      },
    },
    {
      title: '额定功率(KW)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'ratedPower',
      valueType: 'digit',
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <InputNumber disabled={config.record.motorOrderNum !== '第三方'} min={0} max={200} />
        );
      },
    },
    {
      title: '编码器', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'ecoderType', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueEnum: {
        0: '单圈绝对编码器',
        1: '多圈绝对编码器',
        2: '增量式编码器',
      },
      valueType: 'select',

      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90

        return (
          <Select
            style={{ width: 120 }}
            disabled={config.record.motorOrderNum !== '第三方'}
            allowClear
            options={[
              {
                value: 0,
                label: '单圈绝对编码器',
              },
              {
                value: 1,
                label: '多圈绝对编码器',
              },
              {
                value: 2,
                label: '增量式编码器',
              },
            ]}
          />
        );
      },
    },

    // editable: (text: any, record: T, index: number) => {
    //   console.log(record);
    // },
    // valueType: 'select',

    {
      title: '抱闸', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'brake',
      valueEnum: {
        0: '不带抱闸',
        1: '带抱闸',
      },
      valueType: 'select',
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90

        return (
          <Select
            style={{ width: 120 }}
            allowClear
            disabled={config.record.motorOrderNum !== '第三方'}
            options={[
              {
                value: 0,
                label: '不带抱闸',
              },
              {
                value: 1,
                label: '带抱闸',
              },
            ]}
          />
        );
      },
    },
    {
      title: '额定速度(rpm)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'ratedSpeed', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90

        return <InputNumber disabled={config.record.motorOrderNum !== '第三方'} />;
      },
    },
    {
      title: '额定电压(V)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'ratedVoltage',
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return <InputNumber disabled={config.record.motorOrderNum !== '第三方'} />;
      },
    },
    {
      title: '电机惯量(10^-4kg·cm2)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'motorInertia', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      width: 150,
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return <InputNumber disabled={config.record.motorOrderNum !== '第三方'} />;
      },
    },

    {
      title: '负载类型', //表头显示的名称
      align: 'center',
      sorter: true,
      dataIndex: 'loadType',
      valueType: 'select',
      valueEnum: {
        1: { text: '水平' },
        2: { text: '旋转' },
        3: { text: '垂直' },
        4: { text: '斜坡' },
        5: { text: '其它' },
      },
    },

    {
      title: '机械结构', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'mechanicalStructure',
      valueType: 'select',
      valueEnum: {
        1: { text: '丝杠' },
        2: { text: '齿轮齿条' },
        3: { text: '皮带轮' },
        4: { text: '圆盘' },
        5: { text: '辊式带' },
        6: { text: '链条' },
      },
    },
    {
      title: '控制模式', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'controlMode', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: (row) => {
        console.log(row);
        return {
          1: { text: 'TO' },
          2: { text: 'Epos' },
          3: { text: 'Speed' },
        };
      },
      initialValue: 1,
      // fieldProps: (form, { rowKey, rowIndex }) => {
      //   // console.log(form);
      //   // console.log(form?.getFieldValue([rowKey || '', 'driveType']), '---form---');

      //   // if (form.getFieldValue([rowKey || '', 'title']) === '不好玩') {
      //   return {
      //     defaultValue: { value: 1, label: 'TO' },
      //     // disabled: true,
      //   };
      //   // }
      //   // if (rowIndex > 9) {
      //   //   return {
      //   //     disabled: true,
      //   //   };
      //   // }
      //   // return {};
      // },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        console.log(_, config, data, '--');
        // 这个事v90

        return (
          <Select
            style={{ width: 120 }}
            allowClear
            options={
              config.record.driveType === '1'
                ? [
                    {
                      value: 1,
                      label: 'TO',
                    },
                    {
                      value: 2,
                      label: 'Epos',
                    },
                    {
                      value: 3,
                      label: 'Speed',
                    },
                  ]
                : [
                    {
                      value: 1,
                      label: 'TO',
                    },
                  ]
            }
          />
        );
      },
    },

    {
      title: '通讯报文', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'commTelegram',
      valueType: 'select',
      valueEnum: {
        105: { text: '105' },
        111: { text: '111' },
        102: { text: '102' },
        3: { text: '3' },
        1: { text: '1' },
      },
      initialValue: 105,
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90

        return (
          <Select
            style={{ width: 120 }}
            allowClear
            // defaultValue={tempValue}
            options={
              config.record.driveType === '1'
                ? [
                    {
                      value: 105,
                      label: '105',
                    },
                    {
                      value: 111,
                      label: '111',
                    },
                    {
                      value: 102,
                      label: '102',
                    },
                    {
                      value: 3,
                      label: '3',
                    },
                    {
                      value: 1,
                      label: '1',
                    },
                  ]
                : [
                    {
                      value: 105,
                      label: '105',
                    },

                    {
                      value: 102,
                      label: '102',
                    },
                    {
                      value: 3,
                      label: '3',
                    },
                  ]
            }
          />
        );
      },
    },

    {
      title: '附加报文', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'additionalTelegram', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        999: { text: 'None' },
        750: { text: '750' },
      },
    },
    {
      title: '电机方向', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      dataIndex: 'motorRotation',
      valueType: 'select',
      valueEnum: {
        0: { text: '正向' },
        1: { text: '反向' },
      },
    },
    {
      title: '齿轮比负载(V90 EPOS)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 160,
      dataIndex: 'gearRationLoad', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        console.log(config.record);
        return (
          <InputNumber
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
          />
        );
      },
    },
    {
      title: '齿轮比电机(V90 EPOS)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 160,
      dataIndex: 'gearRationMotor',
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <InputNumber
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
          />
        );
      },
    },

    {
      title: '定位精度(V90 EPOS)（mm）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 180,
      dataIndex: 'positionAccuracy', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        3: { text: '0.1mm' },
        2: { text: '0.01mm' },
        1: { text: '0.001mm' },
        6: { text: '0.1°' },
        5: { text: '0.01°' },
        4: { text: '0.001°' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90

        return (
          <Select
            style={{ width: 120 }}
            allowClear
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
            options={[
              {
                value: 3,
                label: '0.1mm',
              },
              {
                value: 2,
                label: '0.01mm',
              },
              {
                value: 1,
                label: '0.001mm',
              },
              {
                value: 6,
                label: '0.1°',
              },
              {
                value: 5,
                label: '0.01°',
              },
              {
                value: 4,
                label: '0.001°',
              },
            ]}
          />
        );
      },
    },
    {
      title: '负载一圈的距离(V90 EPOS) （mm/°）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 200,
      dataIndex: 'loadOneTurnDistance',
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <InputNumber
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
          />
        );
      },
    },
    {
      title: '软限位激活(V90 EPOS)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 180,
      dataIndex: 'softLimitActive', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: 'Yes' },
        2: { text: 'No' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90

        return (
          <Select
            style={{ width: 120 }}
            allowClear
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
            options={[
              {
                value: 1,
                label: 'Yes',
              },
              {
                value: 2,
                label: 'No',
              },
            ]}
          />
        );
      },
    },
    {
      title: '软限位(正)(V90 EPOS) （mm）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 180,
      dataIndex: 'softLimitPositive',
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <InputNumber
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
          />
        );
      },
    },

    {
      title: '软限位(负)(V90 EPOS) （mm）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 180,
      dataIndex: 'softLimitNegative', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <InputNumber
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
          />
        );
      },
    },
    {
      title: '0-Vmax时间(V90 EPOS) （s）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 180,
      dataIndex: 'increaseTimeEpos',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: '0.5-1.0' },
        6: { text: '1.0-2.0' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90

        return (
          <Select
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 1,
                label: '<0.05',
              },
              {
                value: 2,
                label: '0.05-0.09',
              },
              {
                value: 3,
                label: '0.1-0.2',
              },
              {
                value: 4,
                label: '0.3-0.4',
              },
              {
                value: 5,
                label: '0.5-1.0',
              },
              {
                value: 6,
                label: '1.0-2.0',
              },
              {
                value: 7,
                label: '2.0-3.0',
              },
              {
                value: 8,
                label: '>3.0',
              },
            ]}
          />
        );
      },
    },
    {
      title: 'Vmax-0时间(V90 EPOS) （s）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 180,
      dataIndex: 'decreaseTimeEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: '0.5-1.0' },
        6: { text: '1.0-2.0' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 1,
                label: '<0.05',
              },
              {
                value: 2,
                label: '0.05-0.09',
              },
              {
                value: 3,
                label: '0.1-0.2',
              },
              {
                value: 4,
                label: '0.3-0.4',
              },
              {
                value: 5,
                label: '0.5-1.0',
              },
              {
                value: 6,
                label: '1.0-2.0',
              },
              {
                value: 7,
                label: '2.0-3.0',
              },
              {
                value: 8,
                label: '>3.0',
              },
            ]}
          />
        );
      },
    },
    {
      title: '模态轴是否激活(V90 EPOS)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 200,
      dataIndex: 'modualActiveEpos',
      valueType: 'select',
      valueEnum: {
        1: { text: 'Yes' },
        2: { text: 'No' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 1,
                label: 'Yes',
              },
              {
                value: 2,
                label: 'No',
              },
            ]}
          />
        );
      },
    },

    {
      title: '模态长度(V90 EPOS) （mm/°）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 160,
      dataIndex: 'modualLengthEpos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <InputNumber
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
          />
        );
      },
    },
    {
      title: 'DI1(V90 EPOS)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 120,
      dataIndex: 'di1Epos',
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 0,
                label: 'None',
              },
              {
                value: 3,
                label: '正限位',
              },
              {
                value: 4,
                label: '负限位',
              },
              {
                value: 2,
                label: '复位',
              },
              {
                value: 24,
                label: '回零开关',
              },
            ]}
          />
        );
      },
    },
    {
      title: 'DI2(V90 EPOS)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 120,
      dataIndex: 'di2Epos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 0,
                label: 'None',
              },
              {
                value: 3,
                label: '正限位',
              },
              {
                value: 4,
                label: '负限位',
              },
              {
                value: 2,
                label: '复位',
              },
              {
                value: 24,
                label: '回零开关',
              },
            ]}
          />
        );
      },
    },
    {
      title: 'DI3(V90 EPOS)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 120,
      dataIndex: 'di3Epos',
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 0,
                label: 'None',
              },
              {
                value: 3,
                label: '正限位',
              },
              {
                value: 4,
                label: '负限位',
              },
              {
                value: 2,
                label: '复位',
              },
              {
                value: 24,
                label: '回零开关',
              },
            ]}
          />
        );
      },
    },

    {
      title: 'DO1(V90 EPOS)', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 120,
      dataIndex: 'do1Epos', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        0: { text: 'None' },
        3: { text: '正限位' },
        4: { text: '负限位' },
        2: { text: '复位' },
        24: { text: '回零开关' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 2)}
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 0,
                label: 'None',
              },
              {
                value: 3,
                label: '正限位',
              },
              {
                value: 4,
                label: '负限位',
              },
              {
                value: 2,
                label: '复位',
              },
              {
                value: 24,
                label: '回零开关',
              },
            ]}
          />
        );
      },
    },
    {
      title: '0-Vmax时间(V90TO/S210) （s）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 200,
      dataIndex: 'increaseTimeTO',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: '0.5-1.0' },
        6: { text: '1.0-2.0' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={
              config.record.driveType === '1' &&
              (config.record.controlMode === 3 || config.record.controlMode === 2)
            }
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 1,
                label: '<0.05',
              },
              {
                value: 2,
                label: '0.05-0.09',
              },
              {
                value: 3,
                label: '0.1-0.2',
              },
              {
                value: 4,
                label: '0.3-0.4',
              },
              {
                value: 5,
                label: '0.5-1.0',
              },
              {
                value: 6,
                label: '1.0-2.0',
              },
              {
                value: 7,
                label: '2.0-3.0',
              },
              {
                value: 8,
                label: '>3.0',
              },
            ]}
          />
        );
      },
    },
    {
      title: 'Vmax-0时间(V90TO/S210) （s）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 200,
      dataIndex: 'decreaseTimeTO', // 列数据在数据项中对应的路径，支持通过数组查询嵌套路径
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: '0.5-1.0' },
        6: { text: '1.0-2.0' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={
              config.record.driveType === '1' &&
              (config.record.controlMode === 3 || config.record.controlMode === 2)
            }
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 1,
                label: '<0.05',
              },
              {
                value: 2,
                label: '0.05-0.09',
              },
              {
                value: 3,
                label: '0.1-0.2',
              },
              {
                value: 4,
                label: '0.3-0.4',
              },
              {
                value: 5,
                label: '0.5-1.0',
              },
              {
                value: 6,
                label: '1.0-2.0',
              },
              {
                value: 7,
                label: '2.0-3.0',
              },
              {
                value: 8,
                label: '>3.0',
              },
            ]}
          />
        );
      },
    },
    {
      title: '0-nmax时间(V90Speed) （s）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 180,
      dataIndex: 'increaseTimeSpeed',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: '0.5-1.0' },
        6: { text: '1.0-2.0' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 3)}
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 1,
                label: '<0.05',
              },
              {
                value: 2,
                label: '0.05-0.09',
              },
              {
                value: 3,
                label: '0.1-0.2',
              },
              {
                value: 4,
                label: '0.3-0.4',
              },
              {
                value: 5,
                label: '0.5-1.0',
              },
              {
                value: 6,
                label: '1.0-2.0',
              },
              {
                value: 7,
                label: '2.0-3.0',
              },
              {
                value: 8,
                label: '>3.0',
              },
            ]}
          />
        );
      },
    },
    {
      title: 'nmax-0时间(V90Speed) （s）', //表头显示的名称
      search: false,
      align: 'center',
      sorter: true,
      width: 180,
      dataIndex: 'decreaseTimeSpeed',
      valueType: 'select',
      valueEnum: {
        1: { text: '<0.05' },
        2: { text: '0.05-0.09' },
        3: { text: '0.1-0.2' },
        4: { text: '0.3-0.4' },
        5: { text: '0.5-1.0' },
        6: { text: '1.0-2.0' },
        7: { text: '2.0-3.0' },
        8: { text: '>3.0' },
      },
      renderFormItem: (_, config, data) => {
        // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
        // console.log(config, '--');
        // 这个事v90
        return (
          <Select
            disabled={!(config.record.driveType === '1' && config.record.controlMode === 3)}
            style={{ width: 120 }}
            allowClear
            options={[
              {
                value: 1,
                label: '<0.05',
              },
              {
                value: 2,
                label: '0.05-0.09',
              },
              {
                value: 3,
                label: '0.1-0.2',
              },
              {
                value: 4,
                label: '0.3-0.4',
              },
              {
                value: 5,
                label: '0.5-1.0',
              },
              {
                value: 6,
                label: '1.0-2.0',
              },
              {
                value: 7,
                label: '2.0-3.0',
              },
              {
                value: 8,
                label: '>3.0',
              },
            ]}
          />
        );
      },
      // renderFormItem: (_, config, data) => {
      //   // 这里返回的值与Protable的render返回的值差不多,能获取到index,row,data 只是这里是获取对象组,外面会在包一层
      //   console.log(config, '--');
      //   // 这个事v90
      //   if (config.record.driveType === '1') {
      //     return <Input disabled={true} />;
      //   } else if (config.record.driveType === '2') {
      //     return (
      //       //这个是v210
      //       <Input disabled={true} />
      //     );
      //   } else {
      //     return <Input />;
      //   }
      // },
    },

    {
      title: '操作',
      align: 'center',
      valueType: 'option',
      key: 'option',
      fixed: 'right',
      render: (text, record, _, action) => [
        <a
          key="editable"
          onClick={() => {
            action?.startEditable?.(record.id);
          }}
        >
          编辑
        </a>,
        <a
          key="delete"
          onClick={() => {
            setDataSource(dataSource.filter((item) => item.id !== record.id));
          }}
        >
          删除
        </a>,
        <EditableProTable.RecordCreator
          key="copy"
          record={{
            ...record,
            id: (Math.random() * 1000000).toFixed(0),
          }}
        >
          <a>复制</a>
        </EditableProTable.RecordCreator>,
      ],
    },
  ];

  // const handleSubmit = async () => {
  //   if (formTitle == '新建售后需求') {
  //     await addAfterSalesNeedInfo(form.getFieldsValue());
  //   } else {
  //     await updateAfterSalesNeedInfo(form.getFieldsValue());
  //   }

  //   message.success('添加成功');
  //   setModalVisit(false);
  //   // 这个爆红不用管(从新加载页面)
  //   actionRef.current.reload();
  // };
  const [error, setError] = useState<ErrorField[]>([]);
  const getErrorInfo = (errors: ErrorField[]) => {
    // return null;
    const errorCount = errors.filter((item) => item.errors.length > 0).length;

    if (!errors || errorCount === 0) {
      return null;
    }
    const scrollToField = (fieldKey: string) => {
      const labelNode = document.querySelector(`label[for="${fieldKey}"]`);
      if (labelNode) {
        labelNode.scrollIntoView(true);
      }
    };
    const errorList = errors.map((err) => {
      if (!err || err.errors.length === 0) {
        return null;
      }
      const key = err.name[0] as string;
      return (
        <li key={key} className={styles.errorListItem} onClick={() => scrollToField(key)}>
          <CloseCircleOutlined className={styles.errorIcon} />
          <div className={styles.errorMessage}>{err.errors[0]}</div>
          <div className={styles.errorField}>{fieldLabels[key]}</div>
        </li>
      );
    });
    return (
      <span className={styles.errorIcon}>
        <Popover
          title="表单校验信息"
          content={errorList}
          overlayClassName={styles.errorPopover}
          trigger="click"
          getPopupContainer={(trigger: HTMLElement) => {
            if (trigger && trigger.parentNode) {
              return trigger.parentNode as HTMLElement;
            }
            return trigger;
          }}
        >
          <CloseCircleOutlined />
        </Popover>
        {errorCount}
      </span>
    );
  };

  const onFinish = async (values: Record<string, any>) => {
    // setError([]);
    console.log(values, dataSource, '---tijiao-1212121---');
    // debugger;
    if (values.licenseCount !== dataSource.length) {
      message.error('驱动数量和轴数量不一致重新填写');
      return;
    }
    try {
      // 新增
      let result = null;

      if (!formDisabled) {
        result = await addAfterSalesNeedInfoEx({
          userId: values.userId.value,
          driveName: values.driveName,
          isProduction: values.isProduction,
          plcType: values.plcType,
          vm: values.vm,
          licenseOrderNum: values.licensOrderId.label,
          licenseCount: values.licenseCount,
          shaftInfoExDtoList: dataSource.map((item) => {
            return {
              identification: item.identification,
              motorOrderNum: item.motorOrderNum,
              driveType: item.driveType,
              hardwareIdentifier: item.hardwareIdentifier,
              motorId: item.motorId,
              ratedCurrent: item.ratedCurrent,
              ratedTorque: item.ratedTorque,
              ratedPower: item.ratedPower,
              ecoderType: item.ecoderType,
              brake: item.brake,
              shaftName: item.shaftName,

              ratedSpeed: item.ratedSpeed,
              ratedVoltage: item.ratedVoltage,
              motorInertia: item.motorInertia,
              loadType: item.loadType,
              mechanicalStructure: item.mechanicalStructure,
              controlMode: item.controlMode,
              additionalTelegram: item.additionalTelegram,
              motorRotation: item.motorRotation,
              gearRationLoad: item.gearRationLoad,
              gearRationMotor: item.gearRationMotor,
              positionAccuracy: item.positionAccuracy,
              softLimitActive: item.softLimitActive,
              softLimitPositive: item.softLimitPositive,
              softLimitNegative: item.softLimitNegative,
              increaseTimeEpos: item.increaseTimeEpos,
              decreaseTimeEpos: item.decreaseTimeEpos,
              modualActiveEpos: item.modualActiveEpos,
              modualLengthEpos: item.modualLengthEpos,
              // commTelegram: item.commTelegram,

              di1Epos: item.di1Epos,
              di2Epos: item.di2Epos,
              di3Epos: item.di3Epos,
              do1Epos: item.do1Epos,
              increaseTimeTO: item.increaseTimeTO,
              decreaseTimeTO: item.decreaseTimeTO,
              increaseTimeSpeed: item.increaseTimeSpeed,
              decreaseTimeSpeed: item.decreaseTimeSpeed,
            };
          }),
        });
      } else {
        // 更新
        result = await updateAfterSalesNeedInfoEx({
          id: location.query.id,
          userId: values.userId.value,
          driveName: values.driveName,
          isProduction: values.isProduction,
          plcType: values.plcType,
          vm: values.vm,
          licenseOrderNum: values.licensOrderId.label,
          licenseCount: values.licenseCount,
          shaftInfoExDtoList: dataSource.map((item) => {
            return {
              identification: item.identification,
              motorOrderNum: item.motorOrderNum,
              driveType: item.driveType,
              hardwareIdentifier: item.hardwareIdentifier,
              motorId: item.motorId,
              ratedCurrent: item.ratedCurrent,
              ratedTorque: item.ratedTorque,
              ratedPower: item.ratedPower,
              ecoderType: item.ecoderType,
              brake: item.brake,
              shaftName: item.shaftName,

              // commTelegram: item.commTelegram,

              ratedSpeed: item.ratedSpeed,
              ratedVoltage: item.ratedVoltage,
              motorInertia: item.motorInertia,
              loadType: item.loadType,
              mechanicalStruct: item.mechanicalStruct,
              controlMode: item.controlMode,
              additionalTelegr: item.additionalTelegr,
              motorRotation: item.motorRotation,
              gearRationLoad: item.gearRationLoad,
              gearRationMotor: item.gearRationMotor,
              positionAccuracy: item.positionAccuracy,
              softLimitActive: item.softLimitActive,
              softLimitPositiv: item.softLimitPositiv,
              softLimitNegativ: item.softLimitNegativ,
              increaseTimeEpos: item.increaseTimeEpos,
              decreaseTimeEpos: item.decreaseTimeEpos,
              modualActiveEpos: item.modualActiveEpos,
              modualLengthEpos: item.modualLengthEpos,
              di1Epos: item.di1Epos,
              di2Epos: item.di2Epos,
              di3Epos: item.di3Epos,
              do1Epos: item.do1Epos,
              increaseTimeTO: item.increaseTimeTO,
              decreaseTimeTO: item.decreaseTimeTO,
              increaseTimeSpeed: item.increaseTimeSpeed,
              decreaseTimeSpeed: item.decreaseTimeSpeed,
            };
          }),
        });
      }
      if (result !== null && result !== undefined) {
        message.success('添加成功');

        history.push({
          pathname: `/sales/salesNeedInfoCustomer`,
        });
      }
    } catch {
      // console.log
    }
  };
  const onTempSave = async () => {
    console.log(formRef.current?.getFieldsFormatValue?.(), '---');

    formRef.current?.validateFieldsReturnFormatValue?.().then(async (values) => {
      try {
        // 新增
        let result = null;

        if (!formDisabled) {
          result = await addTempAfterSalesNeedInfoEx({
            userId: values.userId.value,
            driveName: values.driveName,
            isProduction: values.isProduction,
            plcType: values.plcType,
            vm: values.vm,
            licenseOrderNum: values.licensOrderId.label,
            licenseCount: values.licenseCount,
            shaftInfoExDtoList: dataSource.map((item) => {
              return {
                identification: item.identification,
                motorOrderNum: item.motorOrderNum,
                driveType: item.driveType,
                hardwareIdentifier: item.hardwareIdentifier,
                motorId: item.motorId,
                ratedCurrent: item.ratedCurrent,
                ratedTorque: item.ratedTorque,
                ratedPower: item.ratedPower,
                ecoderType: item.ecoderType,
                brake: item.brake,
                shaftName: item.shaftName,
              };
            }),
          });
        } else {
          // 更新
          result = await updateTempAfterSalesNeedInfoEx({
            id: location.query.id,
            userId: values.userId.value,
            driveName: values.driveName,
            isProduction: values.isProduction,
            plcType: values.plcType,
            vm: values.vm,
            licenseOrderNum: values.licensOrderId.label,
            licenseCount: values.licenseCount,
            shaftInfoExDtoList: dataSource.map((item) => {
              return {
                identification: item.identification,
                motorOrderNum: item.motorOrderNum,
                driveType: item.driveType,
                hardwareIdentifier: item.hardwareIdentifier,
                motorId: item.motorId,
                ratedCurrent: item.ratedCurrent,
                ratedTorque: item.ratedTorque,
                ratedPower: item.ratedPower,
                ecoderType: item.ecoderType,
                brake: item.brake,
                shaftName: item.shaftName,
              };
            }),
          });
        }
        if (result !== null && result !== undefined) {
          message.success('添加成功');

          history.push({
            pathname: `/sales/salesNeedInfoCustomer`,
          });
        }
      } catch {
        // console.log
      }
      console.log('临时保存=====');
    });

    // const values = formRef.current?.getFieldsFormatValue?.();
  };
  const onFinishFailed = (errorInfo: any) => {
    setError(errorInfo.errorFields);
  };

  /**
   * 穿梭框的数据设置
   */

  return (
    <ProForm
      layout="vertical"
      hideRequiredMark
      submitter={{
        render: (props, dom) => {
          if (access.aperatorFilter('salesCreateAndSave') && location.query.status !== 5) {
            return (
              <FooterToolbar>
                {dom}
                <Button htmlType="button" key="edit" onClick={onTempSave}>
                  保存
                </Button>
              </FooterToolbar>
            );
          }
        },
      }}
      formRef={formRef}
      initialValues={{ members: tableData }}
      onFinish={onFinish}
      onFinishFailed={onFinishFailed}
    >
      <PageHeaderWrapper>
        <Card
          title="用户信息"
          className={styles.card}
          bordered={false}
          extra={
            <Button
              htmlType="button"
              type="primary"
              key="edit"
              onClick={() => {
                afterSalesDetailExport({ id: location.query.id }).then((res) => {
                  const aLink = document.createElement('a');
                  document.body.appendChild(aLink);
                  aLink.style.display = 'none';
                  aLink.href = window.URL.createObjectURL(res);
                  aLink.setAttribute('download', `设备信息登记表${new Date()}.xlsx`);
                  aLink.click();
                  document.body.removeChild(aLink);
                });
              }}
            >
              导出详情
            </Button>
          }
        >
          <Row gutter={16}>
            <Col lg={6} md={12} sm={24}>
              <ProFormSelect
                // options={[
                //   {
                //     value: 'chapter',
                //     label: '盖章后生效',
                //   },
                // ]}

                initialValue={
                  formAdd
                    ? { label: currentUser?.name, value: currentUser?.id }
                    : { label: user.name, value: user.id }
                }
                disabled
                fieldProps={{
                  labelInValue: true,
                  //这里使用了select的onChange方法，必须使用这样的写法来进行调用onChange方法
                  onChange: (val, val2) => {
                    formRef?.current?.setFieldsValue({
                      address: val2?.object?.loginName,
                      phone: val2?.object?.phone,
                    });
                    console.log(val, val2);
                  },
                }}
                debounceTime={1000}
                name="userId"
                label="用户名"
                showSearch
                request={async (para) => {
                  console.log(para, '--para-');
                  const result = await userList({ blurry: para.keyWords });
                  return result.data.map((item) => {
                    return { label: item.name, value: item.id, object: item };
                  });
                }}
              />
            </Col>
            <Col xl={{ span: 6, offset: 2 }} lg={{ span: 8 }} md={{ span: 12 }} sm={24}>
              <ProFormSelect
                // options={[
                //   {
                //     value: 'chapter',
                //     label: '盖章后生效',
                //   },
                // ]}
                rules={[
                  {
                    required: true,
                    message: '请输入订货号',
                  },
                ]}
                fieldProps={{
                  labelInValue: true,
                  //这里使用了select的onChange方法，必须使用这样的写法来进行调用onChange方法
                  onChange: (val, val2) => {
                    // formRef?.current?.setFieldsValue({
                    //   address: val2?.object?.loginName,
                    //   phone: val2?.object?.phone,
                    // });
                    // console.log(val, val2);
                  },
                }}
                debounceTime={1000}
                disabled={formDisabled}
                name="licensOrderId"
                label="订货号"
                showSearch
                request={async (para) => {
                  console.log(para, '--para-');
                  const result = await licenseOrderList({ blurry: para.keyWords });
                  return result.data.map((item) => {
                    return { label: item.licenseOrderNum, value: item.id, object: item };
                  });
                }}
              />
            </Col>
            <Col xl={{ span: 8, offset: 2 }} lg={{ span: 10 }} md={{ span: 24 }} sm={24}>
              <ProFormDigit
                label="授权号数量"
                name="licenseCount"
                rules={[
                  {
                    required: true,
                    message: '请输入授权号数量',
                  },
                ]}
                // rules={[{ required: true, message: '请输入用户地址' }]}
                placeholder="授权号数量"
              />
            </Col>
          </Row>
        </Card>
        <Card title="驱动参数列表" className={styles.card} bordered={false}>
          <Row gutter={16}>
            <Col lg={6} md={12} sm={24}>
              {/* <ProFormSelect
                // options={[
                //   {
                //     value: 'chapter',
                //     label: '盖章后生效',
                //   },
                // ]}
                fieldProps={{
                  labelInValue: true,
                  //这里使用了select的onChange方法，必须使用这样的写法来进行调用onChange方法
                  onChange: (val, val2) => {
                    console.log(val, val2);
                  },
                }}
                initialValue={formAdd ? {} : { label: deviceInfo.deviceName, value: deviceInfo.id }}
                debounceTime={1000}
                name="deviceId"
                label="设备信息"
                showSearch
                request={async (para) => {
                  console.log(para, '--para-');
                  const result = await deviceList({ blurry: para.keyWords });
                  return result.data.map((item) => {
                    return { label: item.deviceName, value: item.id, object: item };
                  });
                }}
              /> */}

              <ProFormText
                label="设备名称"
                name="driveName"
                rules={[
                  {
                    required: true,
                    message: '请输入设备名称',
                  },
                ]}
                disabled={formDisabled}
                // rules={[{ required: true, message: '请选择' }]}
              />
            </Col>
            <Col xl={{ span: 6, offset: 2 }} lg={{ span: 8 }} md={{ span: 12 }} sm={24}>
              <ProFormSelect
                // options={[
                //   {
                //     value: 'chapter',
                //     label: '盖章后生效',
                //   },
                // ]}
                fieldProps={{
                  //这里使用了select的onChange方法，必须使用这样的写法来进行调用onChange方法
                  onChange: (val, val2) => {
                    console.log(val, val2);
                  },
                }}
                initialValue={formAdd ? 1 : null}
                name="vm"
                label="行业"
                options={[
                  { label: '电子', value: 1 },
                  { label: '电池', value: 2 },
                  { label: '物流', value: 3 },
                  { label: '汽车', value: 4 },
                  { label: '太阳能', value: 5 },
                  { label: '增材制造', value: 6 },
                  { label: '包装', value: 7 },
                  { label: '食品饮料', value: 8 },
                  { label: '金属加工', value: 9 },
                  { label: '其他', value: 10 },
                ]}
              />
            </Col>
            <Col xl={{ span: 8, offset: 2 }} lg={{ span: 10 }} md={{ span: 24 }} sm={24}>
              <ProFormSelect
                // options={[
                //   {
                //     value: 'chapter',
                //     label: '盖章后生效',
                //   },
                // ]}
                fieldProps={{
                  //这里使用了select的onChange方法，必须使用这样的写法来进行调用onChange方法
                  onChange: (val, val2) => {
                    console.log(val, val2);
                  },
                }}
                initialValue={formAdd ? 1 : null}
                name="isProduction"
                label="是否量产"
                options={[
                  { label: '是', value: 1 },
                  { label: '否', value: 0 },
                ]}
              />
            </Col>
          </Row>
          <Row gutter={16}>
            <Col lg={6} md={12} sm={24}>
              <ProFormSelect
                // options={[
                //   {
                //     value: 'chapter',
                //     label: '盖章后生效',
                //   },
                // ]}
                fieldProps={{
                  //这里使用了select的onChange方法，必须使用这样的写法来进行调用onChange方法
                  onChange: (val, val2) => {
                    console.log(val, val2);
                  },
                }}
                initialValue={formAdd ? '1' : null}
                name="plcType"
                label="PLC类型"
                options={[
                  { label: 'S7-1500', value: '1' },
                  { label: 'S7-1200', value: '0' },
                ]}
              />
            </Col>
            <Col xl={{ span: 6, offset: 2 }} lg={{ span: 8 }} md={{ span: 12 }} sm={24} />
          </Row>
        </Card>

        <Card title="轴信息" className={styles.card} bordered={false}>
          <EditableProTable<TableFormDateType>
            value={dataSource}
            editableFormRef={editorFormRef}
            scroll={{ x: 6000 }}
            toolBarRender={(action, { selectedRows }) => {
              const array = [];
              array.push(
                <Button
                  key="button"
                  icon={<PlusOutlined />}
                  onClick={() => {
                    // console.log(selectedRows, '---选取多行----');
                    // 1.清空form
                    SetShowUploadFile(true);
                  }}
                  type="primary"
                >
                  上传轴信息
                </Button>,
              );
              array.push(
                <Button
                  key="button"
                  icon={<PlusOutlined />}
                  onClick={() => {
                    // console.log(selectedRows, '---选取多行----');
                    // 1.清空form
                    downloadTemplateByName({ fileName: '电机上传模板.xlsx' }).then((res) => {
                      const aLink = document.createElement('a');
                      document.body.appendChild(aLink);
                      aLink.style.display = 'none';
                      aLink.href = window.URL.createObjectURL(res);
                      aLink.setAttribute('download', `电机上传模板.xlsx`);
                      aLink.click();
                      document.body.removeChild(aLink);
                    });
                  }}
                  type="primary"
                >
                  下载上传模板
                </Button>,
              );
              return array;
            }}
            // editable={{
            //   type: 'multiple',
            //   onChange: (rowKey, row) => {
            //     console.log(rowKey, row, '--rowKey---');
            //   },
            // }}
            recordCreatorProps={{
              record: () => {
                return {
                  id: `0${Date.now()}`,
                  // controlMode: 1,
                  // commTelegram: 105,
                  // controlMode: { value: 1, label: 'TO' },
                  // commTelegram: { value: 105, label: '105' },
                };
              },
            }}
            // request={async () => ({
            //   data: defaultData,
            //   total: 3,
            //   success: true,
            // })}
            onChange={setDataSource}
            columns={columns}
            rowKey="id"
          />
        </Card>
        <UploadFile
          visible={showUploadFile}
          tableHeader={columns}
          errorStatus={errorStatus}
          onOk={(tables, tableHeader) => {
            setDataSource(tables);
            SetErrorStatus(false);
            console.log(tables, tableHeader, '--tableData---');
            SetShowUploadFile(false);
          }}
          onCheck={(tables) => {
            SetErrorStatus(true);
            tables.map((item) => (item.errorMsg = '测试'));
            return tables;
          }}
          onCancel={() => {
            SetShowUploadFile(false);
          }}
          title="excel预览"
        />
      </PageHeaderWrapper>
    </ProForm>
  );
};

export default SalesNeedInfoDetail;
